﻿using System.Text.RegularExpressions;

namespace LowCoding.Common
{
    /// <summary>
    /// 验证类
    /// </summary>
    public static class ValidateHelper
    {
        #region 根据正则返回验证结果

        /// <summary>
        /// 根据正则返回验证结果
        /// </summary>
        /// <param name="input"></param>
        /// <param name="pattern"></param>
        /// <returns></returns>
        public static bool IsMatch(string input, string pattern, RegexOptions options = RegexOptions.None)
        {
            return Regex.IsMatch(input, pattern, options);
        }

        #endregion 根据正则返回验证结果

        #region 判断对象是否为空

        /// <summary>
        /// 判断对象是否为空，为空返回true
        /// </summary>
        /// <typeparam name="T">要验证的对象的类型</typeparam>
        /// <param name="data">要验证的对象</param>
        public static bool IsNullOrEmpty<T>(this T data)
        {
            //如果为null
            if (data == null)
            {
                return true;
            }

            //如果为""
            if (data.GetType() == typeof(String))
            {
                if (string.IsNullOrEmpty(data.ToString().Trim()) || data.ToString() == "")
                {
                    return true;
                }
            }

            //如果为DBNull
            if (data.GetType() == typeof(DBNull))
            {
                return true;
            }

            //不为空
            return false;
        }

        /// <summary>
        /// 判断对象是否为空，为空返回true
        /// </summary>
        /// <param name="data">要验证的对象</param>
        public static bool IsNullOrEmpty(this object data)
        {
            //如果为null
            if (data == null)
            {
                return true;
            }

            //如果为""
            if (data.GetType() == typeof(String))
            {
                if (string.IsNullOrEmpty(data.ToString().Trim()))
                {
                    return true;
                }
            }

            //如果为DBNull
            if (data.GetType() == typeof(DBNull))
            {
                return true;
            }

            //不为空
            return false;
        }

        #endregion 判断对象是否为空

        #region 判断是否有值

        /// <summary>
        /// 判断是否有值
        /// </summary>
        /// <param name="thisValue"></param>
        /// <returns></returns>
        public static bool HasValue(this object thisValue)
        {
            if (thisValue == null || thisValue == DBNull.Value)
                return false;
            return thisValue.ToString() != "";
        }

        #endregion 判断是否有值

        #region 判断是否为空

        /// <summary>
        /// 判断是否为空
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static bool IsNullOrEmptyOrWhiteSpace(this string value)
        {
            return string.IsNullOrEmpty(value) || string.IsNullOrWhiteSpace(value);
        }

        #endregion 判断是否为空

        #region 验证是否为浮点数

        /// <summary>
        /// 验证是否浮点数
        /// </summary>
        /// <param name="floatNum"></param>
        /// <returns></returns>
        public static bool IsFloat(this string floatNum)
        {
            //如果为空，认为验证不合格
            if (IsNullOrEmpty(floatNum))
            {
                return false;
            }
            //清除要验证字符串中的空格
            floatNum = floatNum.Trim();

            //模式字符串
            string pattern = @"^(-?\d+)(\.\d+)?$";

            //验证
            return IsMatch(floatNum, pattern);
        }

        #endregion 验证是否为浮点数

        #region 验证是否为decimal

        /// <summary>
        /// 验证是否为decimal
        /// </summary>
        /// <param name="decimalnum"></param>
        /// <returns></returns>
        public static bool IsDecimal(this string decimalnum)
        {
            //如果为空，认为验证不合格
            if (IsNullOrEmpty(decimalnum))
            {
                return false;
            }
            //清除要验证字符串中的空格
            decimalnum = decimalnum.Trim();

            //模式字符串
            decimal resdecimal;
            return Decimal.TryParse(decimalnum, out resdecimal);
        }

        #endregion 验证是否为decimal

        #region 验证是否为bool

        /// <summary>
        /// 验证是否为bool
        /// </summary>
        /// <param name="decimalnum"></param>
        /// <returns></returns>
        public static bool IsBool(this string boolstr)
        {
            //如果为空，认为验证不合格
            if (IsNullOrEmpty(boolstr))
            {
                return false;
            }
            //清除要验证字符串中的空格

            //模式字符串
            bool resbool;
            return bool.TryParse(boolstr, out resbool);
        }

        #endregion 验证是否为bool

        #region 是否为IP

        /// <summary>
        /// 是否为IP
        /// </summary>
        public static bool IsIP(string ip)
        {
            if (IsNullOrEmpty(ip))
            {
                return false;
            }
            //模式字符串
            string pattern = @"^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$";

            //验证
            return IsMatch(ip, pattern);
        }

        #endregion 是否为IP

        #region 验证为整数或两位小数数值

        public static bool IsNumberic(this string number)
        {
            //如果为空，认为验证不合格
            if (IsNullOrEmpty(number))
            {
                return false;
            }

            //清除要验证字符串中的空格
            number = number.Trim();

            //模式字符串
            string pattern = @"^\d+(\.\d{1,2})?$";

            //验证
            return IsMatch(number, pattern);
        }

        #endregion 验证为整数或两位小数数值

        #region 验证是否为整数

        /// <summary>
        /// 验证是否为整数 如果为空，认为验证不合格 返回false
        /// </summary>
        /// <param name="number">要验证的整数</param>
        public static bool IsInt(this string number)
        {
            //如果为空，认为验证不合格
            if (IsNullOrEmpty(number))
            {
                return false;
            }

            //清除要验证字符串中的空格
            number = number.Trim();
            //模式字符串
            string pattern = @"^-?[0-9]+[0-9]*$";

            //验证
            return IsMatch(number, pattern);
        }

        #endregion 验证是否为整数

        #region 判断字符串中包含字符串

        /// <summary>
        /// 判断字符串中包含字符串
        /// </summary>
        /// <param name="str">字符串</param>
        /// <param name="containsstr">包含字符串</param>
        /// <returns></returns>
        public static bool IsContains(string str, string containsstr)
        {
            if (IsNullOrEmpty(str))
            {
                return false;
            }
            if (IsNullOrEmpty(containsstr))
            {
                return false;
            }
            if (str.Contains(containsstr))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        #endregion 判断字符串中包含字符串

        #region 验证日期是否合法

        /// <summary>
        /// 是否是日期
        /// </summary>
        /// <param name="date"></param>
        /// <returns></returns>
        public static bool IsDate(this object date)
        {
            //如果为空，认为验证合格
            if (IsNullOrEmpty(date))
            {
                return false;
            }
            string strdate = date.ToString();
            try
            {
                //用转换测试是否为规则的日期字符
                date = Convert.ToDateTime(date).ToString("d");
                return true;
            }
            catch
            {
                //如果日期字符串中存在非数字，则返回false
                if (!IsInt(strdate))
                {
                    return false;
                }

                #region 对纯数字进行解析

                //对8位纯数字进行解析
                if (strdate.Length == 8)
                {
                    //获取年月日
                    string year = strdate.Substring(0, 4);
                    string month = strdate.Substring(4, 2);
                    string day = strdate.Substring(6, 2);

                    //验证合法性
                    if (Convert.ToInt32(year) < 1900 || Convert.ToInt32(year) > 2100)
                    {
                        return false;
                    }
                    if (Convert.ToInt32(month) > 12 || Convert.ToInt32(day) > 31)
                    {
                        return false;
                    }

                    //拼接日期
                    date = Convert.ToDateTime(year + "-" + month + "-" + day).ToString("d");
                    return true;
                }

                //对6位纯数字进行解析
                if (strdate.Length == 6)
                {
                    //获取年月
                    string year = strdate.Substring(0, 4);
                    string month = strdate.Substring(4, 2);

                    //验证合法性
                    if (Convert.ToInt32(year) < 1900 || Convert.ToInt32(year) > 2100)
                    {
                        return false;
                    }
                    if (Convert.ToInt32(month) > 12)
                    {
                        return false;
                    }

                    //拼接日期
                    date = Convert.ToDateTime(year + "-" + month).ToString("d");
                    return true;
                }

                //对5位纯数字进行解析
                if (strdate.Length == 5)
                {
                    //获取年月
                    string year = strdate.Substring(0, 4);
                    string month = strdate.Substring(4, 1);

                    //验证合法性
                    if (Convert.ToInt32(year) < 1900 || Convert.ToInt32(year) > 2100)
                    {
                        return false;
                    }

                    //拼接日期
                    date = year + "-" + month;
                    return true;
                }

                //对4位纯数字进行解析
                if (strdate.Length == 4)
                {
                    //获取年
                    string year = strdate.Substring(0, 4);

                    //验证合法性
                    if (Convert.ToInt32(year) < 1900 || Convert.ToInt32(year) > 2100)
                    {
                        return false;
                    }

                    //拼接日期
                    date = Convert.ToDateTime(year).ToString("d");
                    return true;
                }

                #endregion 对纯数字进行解析

                return false;
            }
        }

        /// <summary>
        /// 验证日期是否合法,对不规则的作了简单处理
        /// </summary>
        /// <param name="date">日期</param>
        public static bool IsDate(ref string date)
        {
            //如果为空，认为验证合格
            if (IsNullOrEmpty(date))
            {
                return true;
            }

            //清除要验证字符串中的空格
            date = date.Trim();

            //替换\
            date = date.Replace(@"\", "-");
            //替换/
            date = date.Replace(@"/", "-");

            //如果查找到汉字"今",则认为是当前日期
            if (date.IndexOf("今") != -1)
            {
                date = DateTime.Now.ToString();
            }

            try
            {
                //用转换测试是否为规则的日期字符
                date = Convert.ToDateTime(date).ToString("d");
                return true;
            }
            catch
            {
                //如果日期字符串中存在非数字，则返回false
                if (!IsInt(date))
                {
                    return false;
                }

                #region 对纯数字进行解析

                //对8位纯数字进行解析
                if (date.Length == 8)
                {
                    //获取年月日
                    string year = date.Substring(0, 4);
                    string month = date.Substring(4, 2);
                    string day = date.Substring(6, 2);

                    //验证合法性
                    if (Convert.ToInt32(year) < 1900 || Convert.ToInt32(year) > 2100)
                    {
                        return false;
                    }
                    if (Convert.ToInt32(month) > 12 || Convert.ToInt32(day) > 31)
                    {
                        return false;
                    }

                    //拼接日期
                    date = Convert.ToDateTime(year + "-" + month + "-" + day).ToString("d");
                    return true;
                }

                //对6位纯数字进行解析
                if (date.Length == 6)
                {
                    //获取年月
                    string year = date.Substring(0, 4);
                    string month = date.Substring(4, 2);

                    //验证合法性
                    if (Convert.ToInt32(year) < 1900 || Convert.ToInt32(year) > 2100)
                    {
                        return false;
                    }
                    if (Convert.ToInt32(month) > 12)
                    {
                        return false;
                    }

                    //拼接日期
                    date = Convert.ToDateTime(year + "-" + month).ToString("d");
                    return true;
                }

                //对5位纯数字进行解析
                if (date.Length == 5)
                {
                    //获取年月
                    string year = date.Substring(0, 4);
                    string month = date.Substring(4, 1);

                    //验证合法性
                    if (Convert.ToInt32(year) < 1900 || Convert.ToInt32(year) > 2100)
                    {
                        return false;
                    }

                    //拼接日期
                    date = year + "-" + month;
                    return true;
                }

                //对4位纯数字进行解析
                if (date.Length == 4)
                {
                    //获取年
                    string year = date.Substring(0, 4);

                    //验证合法性
                    if (Convert.ToInt32(year) < 1900 || Convert.ToInt32(year) > 2100)
                    {
                        return false;
                    }

                    //拼接日期
                    date = Convert.ToDateTime(year).ToString("d");
                    return true;
                }

                #endregion 对纯数字进行解析

                return false;
            }
        }

        /// <summary>
        /// 验证日期格式是否为yyyyMMddhhmmss
        /// </summary>
        /// <param name="date"></param>
        /// <returns></returns>
        public static bool IsDateyyyyMMddHHmmssNons(this string date)
        {
            //如果为空，认为验证不合格
            if (IsNullOrEmpty(date))
            {
                return false;
            }
            //清除要验证字符串中的空格
            date = date.Trim();
            //模式字符串
            string pattern = @"^((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3})(((0[13578]|1[02])(0[1-9]|[12][0-9]|3[01]))|((0[469]|11)(0[1-9]|[12][0-9]|30))|(02(0[1-9]|[1][0-9]|2[0-8]))))|((([0-9]{2})(0[48]|[2468][048]|[13579][26])|((0[48]|[2468][048]|[3579][26])00))0229))([0-1]?[0-9]|2[0-3])([0-5][0-9])([0-5][0-9])$";
            //验证
            return IsMatch(date, pattern);
        }

        /// <summary>
        /// 验证日期格式是否为yyyyMMdd
        /// </summary>
        /// <param name="date"></param>
        /// <returns></returns>
        public static bool IsDateyyyyMMdd(this string date)
        {
            //如果为空，认为验证不合格
            if (IsNullOrEmpty(date))
            {
                return false;
            }
            //清除要验证字符串中的空格
            date = date.Trim();
            //模式字符串
            string pattern = @"^((([0-9][0-9][0-9][1-9])|([1-9][0-9][0-9][0-9])|([0-9][1-9][0-9][0-9])|([0-9][0-9][1-9][0-9]))-((0[13578])|(1[02]))-((0[1-9])|([12][0-9])|(3[01])))|((([0-9][0-9][0-9][1-9])|([1-9][0-9][0-9][0-9])|([0-9][1-9][0-9][0-9])|([0-9][0-9][1-9][0-9]))-((0[469])|11)-((0[1-9])|([12][0-9])|(30)))|(((000[48])|([0-9]0-9)|([0-9][1-9][02468][048])|([1-9][0-9][02468][048]))-02-((0[1-9])|([12][0-9])))|((([0-9][0-9][0-9][1-9])|([1-9][0-9][0-9][0-9])|([0-9][1-9][0-9][0-9])|([0-9][0-9][1-9][0-9]))-02-((0[1-9])|([1][0-9])|([2][0-8])))$";
            //验证
            return IsMatch(date, pattern);
        }

        /// <summary>
        /// 验证日期格式是否为yyyy-MM-dd hh:mm:ss
        /// </summary>
        /// <param name="date"></param>
        /// <returns></returns>
        public static bool IsDateyyyyMMddHHmmss(this string date)
        {
            //
            //如果为空，认为验证不合格
            if (IsNullOrEmpty(date))
            {
                return false;
            }
            //清除要验证字符串中的空格
            date = date.Trim();
            //模式字符串
            string pattern = @"^((\d{2}(([02468][048])|([13579][26]))[\-\/\s]?((((0?[13578])|(1[02]))[\-\/\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\-\/\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\-\/\s]?((0?[1-9])|([1-2][0-9])))))|(\d{2}(([02468][1235679])|([13579][01345789]))[\-\/\s]?((((0?[13578])|(1[02]))[\-\/\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\-\/\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\-\/\s]?((0?[1-9])|(1[0-9])|(2[0-8]))))))(\s((([0-1][0-9])|(2?[0-3]))\:([0-5]?[0-9])((\s)|(\:([0-5]?[0-9])))))?$";
            //验证
            return IsMatch(date, pattern);
        }

        /// <summary>
        /// 验证日期格式是否为HHmmss
        /// </summary>
        /// <param name="date"></param>
        /// <returns></returns>
        public static bool IsHHmmss(this string date)
        {
            if (IsNullOrEmpty(date))
            {
                return false;
            }
            return IsMatch(date, "^([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$");
        }

        #endregion 验证日期是否合法

        #region 判断字符串只包含汉字

        /// <summary>
        /// 判断字符串只包含汉字
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsChineseCh(string input)
        {
            return IsMatch(input, "^[\u4e00-\u9fa5]+$");
        }

        #endregion 判断字符串只包含汉字

        #region 判断是否为电话号码

        /// <summary>
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsPhone(string input)
        {
            return IsMatch(input, "^\\(0\\d{2}\\)[- ]?\\d{8}$|^0\\d{2}[- ]?\\d{8}$|^\\(0\\d{3}\\)[- ]?\\d{7}$|^0\\d{3}[- ]?\\d{7}$");
        }

        #endregion 判断是否为电话号码

        #region 判断是否为手机号码

        /// <summary>
        /// 判断是否为手机号码
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsMobilePhone(this string input)
        {
            return IsMatch(input, @"^1(2|3|4|5|6|7|8|9)\d{9}$");
        }

        #endregion 判断是否为手机号码

        #region 判断是否为身份证

        /// <summary>
        /// 判断是否为身份证
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsIdCard(string input)
        {
            return IsMatch(input, @"^\d{15}(\d{2}[A-Za-z0-9])?$/i.test(value) || /^\d{18}(\d{2}[A-Za-z0-9])?$");
        }

        #endregion 判断是否为身份证

        #region 判断输入的字符串只包含数字

        /// <summary>
        /// 判断输入的字符串只包含数字
        /// 可以匹配整数和浮点数
        /// ^-?\d+$|^(-?\d+)(\.\d+)?$
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsNumber(string input)
        {
            return IsMatch(input, "^-?\\d+$|^(-?\\d+)(\\.\\d+)?$");
        }

        #endregion 判断输入的字符串只包含数字

        #region 判断输入的字符串仅为0或者1 且长度为1

        /// <summary>
        /// 判断输入的字符串仅为0或者1 且长度为1
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsZeroOrOne(string input)
        {
            return IsMatch(input, "^[0|1]{1}$");
        }

        #endregion 判断输入的字符串仅为0或者1 且长度为1

        #region 匹配非负整数

        /// <summary>
        /// 匹配非负整数
        ///
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsNotNagtive(this string number)
        {
            //如果为空，认为验证不合格
            if (IsNullOrEmpty(number))
            {
                return false;
            }
            //清除要验证字符串中的空格
            number = number.Trim();
            //模式字符串
            string pattern = @"^\d+$";

            //验证
            return IsMatch(number, pattern);
        }

        #endregion 匹配非负整数

        #region 匹配正整数

        /// <summary>
        /// 匹配正整数
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsUint(this string number)
        {
            //如果为空，认为验证不合格
            if (IsNullOrEmpty(number))
            {
                return false;
            }
            //清除要验证字符串中的空格
            number = number.Trim();
            string pattern = @"^[0-9]*[1-9][0-9]*$";
            //验证
            return IsMatch(number, pattern);
        }

        #endregion 匹配正整数

        #region 匹配正数

        /// <summary>
        /// 匹配正数
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsNumNotMinus(this string input)
        {
            bool isMatch = IsMatch(input, @"^[0]*([.]\d+)$");
            if (isMatch == false)
            {
                bool isMatch1 = IsMatch(input, @"^[1-9][0-9]*([.]\d+)?$");
                if (isMatch1 == true)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return true;
            }
        }

        #endregion 匹配正数

        #region 判断输入的字符串字包含英文字母

        /// <summary>
        /// 判断输入的字符串字包含英文字母
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsEnglisCh(string input)
        {
            return IsMatch(input, "^[A-Za-z]+$");
        }

        #endregion 判断输入的字符串字包含英文字母

        #region 判断输入的字符串是否是一个合法的Email地址

        /// <summary>
        /// 判断输入的字符串是否是一个合法的Email地址
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsEmail(string input)
        {
            return IsMatch(input, @"^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$");
        }

        #endregion 判断输入的字符串是否是一个合法的Email地址

        #region 判断输入的字符串是否只包含数字和英文字母

        /// <summary>
        /// 判断输入的字符串是否只包含数字和英文字母
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsNumAndEnCh(string input)
        {
            return IsMatch(input, @"^[A-Za-z0-9]+$");
        }

        #endregion 判断输入的字符串是否只包含数字和英文字母

        #region 判断输入的字符串是否只包含英文字母和下划线

        /// <summary>
        /// 判断输入的字符串是否只包含数字和英文字母
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsenglishUnderline(string input)
        {
            return IsMatch(input, @"^[a-zA-Z_]+$");
        }

        #endregion 判断输入的字符串是否只包含英文字母和下划线

        #region 判断输入的字符串是否是一个超链接

        /// <summary>
        /// 判断输入的字符串是否是一个超链接
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsURL(string input)
        {
            return IsMatch(input, @"^http(s)?://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?$");
        }

        #endregion 判断输入的字符串是否是一个超链接

        #region 判断输入的字符串是否是表示一个IPv4地址

        /// <summary>
        /// 判断输入的字符串是否是表示一个IPv4地址
        /// </summary>
        /// <param name="input">被比较的字符串</param>
        /// <returns>是IP地址则为True</returns>
        public static bool IsIPv4(this string input)
        {
            string[] IPs = input.Split('.');
            Regex regex = new Regex(@"^\d+$");
            for (int i = 0; i < IPs.Length; i++)
            {
                if (!regex.IsMatch(IPs[i]))
                {
                    return false;
                }
                if (Convert.ToUInt16(IPs[i]) > 255)
                {
                    return false;
                }
            }
            return true;
        }

        #endregion 判断输入的字符串是否是表示一个IPv4地址

        #region 判断输入的字符串是否是表示一个IPv6地址

        /// <summary>
        /// 判断输入的字符串是否是表示一个IPv6地址
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsIPv6(this string input)
        {
            //如果为空，认为验证不合格
            if (IsNullOrEmpty(input))
            {
                return false;
            }
            string pattern = @"^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$";
            //验证
            return IsMatch(input, pattern);
        }

        #endregion 判断输入的字符串是否是表示一个IPv6地址

        #region 检查字符串是否存在与一个分隔符组合到一起的字符串数组中

        /// <summary>
        /// 检查字符串是否存在与一个分隔符组合到一起的字符串数组中
        /// </summary>
        /// <param name="strSplit">未分割的字符串</param>
        /// <param name="split">分割符号</param>
        /// <param name="targetValue">目标字符串</param>
        /// <returns></returns>
        public static bool CheckStringHasValue(string strSplit, char split, string targetValue)
        {
            string[] strList = strSplit.Split(split);
            foreach (string str in strList)
            {
                if (targetValue == str)
                    return true;
            }
            return false;
        }

        #endregion 检查字符串是否存在与一个分隔符组合到一起的字符串数组中

        #region 判断是否是正确的统一社会信用代码

        /// <summary>
        ///
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool ISSocialcrditcode(string input)
        {
            return IsMatch(input, @"/^[^_IOZSVa-z\W]{2}\d{6}[^_IOZSVa-z\W]{10}$/g");
        }

        #endregion 判断是否是正确的统一社会信用代码
    }
}